static void _gtk_rbnode_free (GtkRBNode *node);
static void _gtk_rbnode_rotate_left (GtkRBTree *tree,
GtkRBNode *node);
-static void _gtk_rbnode_rotate_left (GtkRBTree *tree,
+static void _gtk_rbnode_rotate_right (GtkRBTree *tree,
GtkRBNode *node);
static void _gtk_rbtree_insert_fixup (GtkRBTree *tree,
GtkRBNode *node);
(right->left?right->left->parity:0) +
(right->right?right->right->parity:0) +
(right->children?right->children->root->parity:0);
+
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ if ((! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) &&
+ (node->right != tree->nil && ! GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (node->left != tree->nil && ! GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+ GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+ }
+ if (GTK_RBNODE_FLAG_SET (right, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ if ((! GTK_RBNODE_FLAG_SET (right, GTK_RBNODE_INVALID)) &&
+ (right->right != tree->nil && ! GTK_RBNODE_FLAG_SET (right->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (right->left != tree->nil && ! GTK_RBNODE_FLAG_SET (right->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (right->children && GTK_RBNODE_FLAG_SET (right->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+ GTK_RBNODE_UNSET_FLAG (right, GTK_RBNODE_DESCENDANTS_INVALID);
+ }
}
static void
(left->left?left->left->parity:0) +
(left->right?left->right->parity:0) +
(left->children?left->children->root->parity:0);
+
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ if ((! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) &&
+ (node->right != tree->nil && ! GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (node->left != tree->nil && ! GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+ GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+ }
+ if (GTK_RBNODE_FLAG_SET (left, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ if ((! GTK_RBNODE_FLAG_SET (left, GTK_RBNODE_INVALID)) &&
+ (left->right != tree->nil && ! GTK_RBNODE_FLAG_SET (left->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (left->left != tree->nil && ! GTK_RBNODE_FLAG_SET (left->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+ (left->children && GTK_RBNODE_FLAG_SET (left->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+ GTK_RBNODE_UNSET_FLAG (left, GTK_RBNODE_DESCENDANTS_INVALID);
+ }
}
static void
}
}
+void
+_gtk_rbtree_node_mark_invalid (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))
+ return;
+
+ GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_INVALID);
+ do
+ {
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))
+ return;
+ GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+ node = node->parent;
+ if (node == NULL)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ }
+ }
+ while (node);
+}
+
+void
+_gtk_rbtree_node_mark_valid (GtkRBTree *tree,
+ GtkRBNode *node)
+{
+ if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))
+ return;
+
+ GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_INVALID);
+ do
+ {
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
+ (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->left && GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) ||
+ (node->right && GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)))
+ return;
+
+ GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+ node = node->parent;
+ if (node == NULL)
+ {
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ }
+ }
+ while (node);
+}
+
typedef struct _GtkRBReorder
{
GtkRBTree *children;
GtkTreeIter *s_iter,
gint *new_order,
gpointer data);
-static void gtk_tree_model_sort_destroy (GtkObject *gobject);
static void gtk_tree_model_sort_row_changed (GtkTreeModel *model,
GtkTreePath *start_path,
SortElt *elt);
static void gtk_tree_model_sort_set_model (GtkTreeModelSort *tree_model_sort,
GtkTreeModel *child_model);
+static GtkTreePath *gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
+ GtkTreePath *child_path,
+ gboolean build_levels);
GType
gtk_tree_model_sort_class_init (GtkTreeModelSortClass *class)
{
GObjectClass *object_class;
- GtkObjectClass *gobject_class;
object_class = (GObjectClass *) class;
- gobject_class = (GtkObjectClass *) class;
object_class->finalize = gtk_tree_model_sort_finalize;
- gobject_class->destroy = gtk_tree_model_sort_destroy;
}
static void
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) object;
+ gtk_tree_model_sort_set_model (tree_model_sort, NULL);
+
if (tree_model_sort->root)
gtk_tree_model_sort_free_level (tree_model_sort, tree_model_sort->root);
}
}
-/* GtkObject callbacks */
-static void
-gtk_tree_model_sort_destroy (GtkObject *gobject)
-{
- GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) gobject;
-
- if (tree_model_sort->child_model)
- gtk_tree_model_sort_set_model (tree_model_sort, NULL);
-}
-
static void
gtk_tree_model_sort_row_changed (GtkTreeModel *s_model,
GtkTreePath *start_s_path,
GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
GtkTreePath *path;
GtkTreeIter iter;
- gboolean free_s_path = FALSE;
- g_return_if_fail (s_path != NULL || s_iter != NULL);
+ g_return_if_fail (s_path != NULL && s_iter != NULL);
- /* we don't handle signals which we don't cover */
- if (!tree_model_sort->root)
- return;
-
- if (!s_path)
- {
- s_path = gtk_tree_model_get_path (s_model, s_iter);
- free_s_path = TRUE;
- }
-
- path = gtk_tree_model_sort_convert_child_path_to_path (tree_model_sort,
- s_path);
- if (!path)
+ path = gtk_real_tree_model_sort_convert_child_path_to_path (tree_model_sort, s_path, FALSE);
+ if (path == NULL)
return;
gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
- gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path,
- &iter);
- gtk_tree_path_free (path);
+ gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path, &iter);
- if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort))
- {
- gtk_tree_model_sort_free_level (tree_model_sort,
- SORT_LEVEL (tree_model_sort->root));
- tree_model_sort->root = NULL;
- }
-
- if (free_s_path)
- gtk_tree_path_free (s_path);
+ gtk_tree_path_free (path);
}
static void
{
GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
GtkTreePath *path = NULL;
+ SortElt *elt;
+ SortLevel *level;
+ GtkTreeIter iter;
+ gint offset;
+ gint i;
+
+ g_return_if_fail (s_path != NULL);
- /* we don't handle signals which we don't cover */
- if (!tree_model_sort->root)
+ path = gtk_real_tree_model_sort_convert_child_path_to_path (tree_model_sort, s_path, FALSE);
+ if (path == NULL)
return;
- g_return_if_fail (s_path != NULL);
- path = gtk_tree_model_sort_convert_child_path_to_path (tree_model_sort,
- s_path);
+ g_print ("path to be deleted: %s\n", gtk_tree_path_to_string (path));
+ gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
- if (!path)
+ level = SORT_LEVEL (iter.user_data);
+ elt = SORT_ELT (iter.user_data2);
+ offset = elt->offset;
+
+ while (elt->ref_count > 0)
+ gtk_tree_model_sort_unref_node (GTK_TREE_MODEL (data), &iter);
+
+ if (level->ref_count == 0)
{
- /* we don't cover this signal */
+ /* This will prune the level, so I can just emit the signal and not worry
+ * about cleaning this level up. */
+ gtk_tree_model_sort_increment_stamp (tree_model_sort);
+ gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
+
+ gtk_tree_path_free (path);
return;
}
-
- if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort))
- {
- gtk_tree_model_sort_free_level (tree_model_sort,
- SORT_LEVEL (tree_model_sort->root));
- tree_model_sort->root = NULL;
- }
- else
- {
- SortElt *elt;
- SortLevel *level;
- GtkTreeIter iter;
- gint offset;
- gint i;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (data),
- &iter, path);
- g_return_if_fail (tree_model_sort->stamp == iter.stamp);
- level = SORT_LEVEL (iter.user_data);
- elt = SORT_ELT (iter.user_data2);
- offset = elt->offset;
- for (i = 0; i < level->array->len; i++)
- if (elt->offset == g_array_index (level->array, SortElt, i).offset)
- break;
-
- g_array_remove_index (level->array, i);
- level->ref_count--;
+ /* Remove the row */
+ for (i = 0; i < level->array->len; i++)
+ if (elt->offset == g_array_index (level->array, SortElt, i).offset)
+ break;
+
+ g_array_remove_index (level->array, i);
- /* update all offsets */
- for (i = 0; i < level->array->len; i++)
- {
- elt = & (g_array_index (level->array, SortElt, i));
- if (elt->offset > offset)
- elt->offset--;
- }
+ /* update all offsets */
+ for (i = 0; i < level->array->len; i++)
+ {
+ elt = & (g_array_index (level->array, SortElt, i));
+ if (elt->offset > offset)
+ elt->offset--;
}
-
+
gtk_tree_model_sort_increment_stamp (tree_model_sort);
gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
- if (path)
- gtk_tree_path_free (path);
+ gtk_tree_path_free (path);
}
static void
int len;
SortElt *elt;
SortLevel *level;
- gboolean free_s_path = FALSE;
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
- g_return_if_fail (s_path != NULL || s_iter != NULL);
+ g_return_if_fail (s_path != NULL && s_iter != NULL);
g_return_if_fail (new_order != NULL);
- if (!s_path)
- {
- s_path = gtk_tree_model_get_path (s_model, s_iter);
- free_s_path = TRUE;
- }
-
if (!gtk_tree_path_get_indices (s_path))
len = gtk_tree_model_iter_n_children (s_model, NULL);
else
if (len < 2)
{
- if (free_s_path)
- gtk_tree_path_free (s_path);
return;
}
if (!path)
{
- if (free_s_path)
- gtk_tree_path_free (s_path);
return;
}
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path))
{
/* no iter for me */
- if (free_s_path)
- gtk_tree_path_free (s_path);
gtk_tree_path_free (path);
return;
}
if (!level)
{
- if (free_s_path)
- gtk_tree_path_free (s_path);
-
/* ignore signal */
return;
}
if (len != level->array->len)
{
- if (free_s_path)
- gtk_tree_path_free (s_path);
-
/* length mismatch, pretty bad, shouldn't happen */
return;
if (!path)
{
- if (free_s_path)
- gtk_tree_path_free (s_path);
-
return;
}
gtk_tree_path_free (path);
- if (free_s_path)
- gtk_tree_path_free (s_path);
-
return;
}
gtk_tree_model_sort_increment_stamp (tree_model_sort);
- if (free_s_path)
- gtk_tree_path_free (s_path);
}
/* Fulfill our model requirements */
if (tree_model_sort->child_model == 0)
return 0;
- return gtk_tree_model_get_n_columns (GTK_TREE_MODEL_SORT (tree_model)->child_model);
+ return gtk_tree_model_get_n_columns (tree_model_sort->child_model);
}
static GType
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
SortLevel *level;
+ iter->stamp = 0;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), FALSE);
g_return_val_if_fail (tree_model_sort->child_model != NULL, FALSE);
if (parent) g_return_val_if_fail (tree_model_sort->stamp == parent->stamp, FALSE);
if (parent == NULL)
{
-
if (tree_model_sort->root == NULL)
gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL);
if (tree_model_sort->root == NULL)
gint n)
{
SortLevel *level;
+ /* We have this for the iter == parent case */
+ GtkTreeIter children;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), FALSE);
- g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->child_model != NULL, FALSE);
+ if (parent) g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->stamp == parent->stamp, FALSE);
- if (gtk_tree_model_sort_iter_children (tree_model, iter, parent) == FALSE)
- return FALSE;
+ /* Use this instead of has_child to force us to build the level, if needed */
+ if (gtk_tree_model_sort_iter_children (tree_model, &children, parent) == FALSE)
+ {
+ iter->stamp = 0;
+ return FALSE;
+ }
- level = iter->user_data;
+ level = children.user_data;
if (n >= level->array->len)
{
iter->stamp = 0;
return FALSE;
}
+ iter->stamp = GTK_TREE_MODEL_SORT (tree_model)->stamp;
+ iter->user_data = level;
iter->user_data2 = &g_array_index (level->array, SortElt, n);
+
return TRUE;
}
{
SortLevel *level;
+ iter->stamp = 0;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), FALSE);
g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->child_model != NULL, FALSE);
g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->stamp == child->stamp, FALSE);
level = iter->user_data;
elt = iter->user_data2;
+ g_return_if_fail (elt->ref_count > 0);
+
elt->ref_count--;
level->ref_count--;
if (level->ref_count == 0)
{
SortLevel *parent_level = level->parent_level;
SortElt *parent_elt = level->parent_elt;
+
/* We were at zero -- time to decrement the zero_ref_count val */
- do
+ while (parent_level)
{
- if (parent_elt)
- parent_elt->zero_ref_count++;
- else
- tree_model_sort->zero_ref_count++;
+ parent_elt->zero_ref_count++;
- if (parent_level)
- {
- parent_elt = parent_level->parent_elt;
- parent_level = parent_level->parent_level;
- }
+ parent_elt = parent_level->parent_elt;
+ parent_level = parent_level->parent_level;
}
- while (parent_level);
+ tree_model_sort->zero_ref_count++;
}
}
GType *types;
gint i, n_columns;
+ g_object_ref (tree_model_sort->child_model);
tree_model_sort->changed_id =
g_signal_connect (child_model, "row_changed",
G_CALLBACK (gtk_tree_model_sort_row_changed),
}
-/**
- * gtk_tree_model_sort_convert_child_path_to_path:
- * @tree_model_sort: A #GtkTreeModelSort
- * @child_path: A #GtkTreePath to convert
- *
- * Converts @child_path to a path relative to @tree_model_sort. That is,
- * @child_path points to a path in the child model. The returned path will
- * point to the same row in the sorted model. If @child_path isn't a valid path
- * on the child model, then %NULL is returned.
- *
- * Return value: A newly allocated #GtkTreePath, or %NULL
- **/
-GtkTreePath *
-gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
- GtkTreePath *child_path)
+static GtkTreePath *
+gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
+ GtkTreePath *child_path,
+ gboolean build_levels)
{
gint *child_indices;
GtkTreePath *retval;
retval = gtk_tree_path_new ();
child_indices = gtk_tree_path_get_indices (child_path);
+ if (tree_model_sort->root == NULL && build_levels)
+ gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL);
level = SORT_LEVEL (tree_model_sort->root);
+
for (i = 0; i < gtk_tree_path_get_depth (child_path); i++)
{
gint j;
if ((g_array_index (level->array, SortElt, j)).offset == child_indices[i])
{
gtk_tree_path_append_index (retval, j);
+ if (g_array_index (level->array, SortElt, j).children == NULL && build_levels)
+ gtk_tree_model_sort_build_level (tree_model_sort, level, &g_array_index (level->array, SortElt, j));
level = g_array_index (level->array, SortElt, j).children;
found_child = TRUE;
break;
return retval;
}
+
+/**
+ * gtk_tree_model_sort_convert_child_path_to_path:
+ * @tree_model_sort: A #GtkTreeModelSort
+ * @child_path: A #GtkTreePath to convert
+ *
+ * Converts @child_path to a path relative to @tree_model_sort. That is,
+ * @child_path points to a path in the child model. The returned path will
+ * point to the same row in the sorted model. If @child_path isn't a valid path
+ * on the child model, then %NULL is returned.
+ *
+ * Return value: A newly allocated #GtkTreePath, or %NULL
+ **/
+GtkTreePath *
+gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
+ GtkTreePath *child_path)
+{
+ g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model_sort), NULL);
+ g_return_val_if_fail (tree_model_sort->child_model != NULL, NULL);
+ g_return_val_if_fail (child_path != NULL, NULL);
+
+ return gtk_real_tree_model_sort_convert_child_path_to_path (tree_model_sort, child_path, TRUE);
+}
+
/**
* gtk_tree_model_sort_convert_child_iter_to_iter:
* @tree_model_sort: A #GtkTreeModelSort
g_assert (sort_level);
+ g_print ("freeing a level\n");
if (sort_level->ref_count == 0)
{
SortLevel *parent_level = sort_level->parent_level;
static void
gtk_tree_model_sort_increment_stamp (GtkTreeModelSort *tree_model_sort)
{
- tree_model_sort->stamp++;
+ while (tree_model_sort->stamp == 0) tree_model_sort->stamp++;
+
gtk_tree_model_sort_clear_cache (tree_model_sort);
}
projects / gtk4.git / commitdiff